/**寄生式组合继承继承 */
export function prototypeNew(Sub, SuperType) {
    function object(obj) {
        // 原型式继承 Object.create()是使用的这种方式，原型式继承的规范化，第一个参数为原型对象，第二个参数是新增属性
        function F() { } // 一个临时的构造函数
        F.prototype = obj.prototype; // 修改临时构造函数的原型指向
        return new F(); // 返回临时构造函数的实例，实际上是对 obj 的一次浅复制
        // 若在return 之前，对F的实例进行修改属性，则为寄生式继承
    }
    let prototype = object(SuperType); // 原型式继承
    prototype.constructor = Sub; // 修改父类构造函数的实例，属于寄生式继承，指定constructor是为了解决重写子类原型导致的constructor丢失
    Sub.prototype = prototype; // 赋值修改prototype
}
//#region 基本概念：
//#region 原型式继承
{
    /**这是一个用于理解原型式继承的函数 */
    function object(obj) {
        function F() { }
        F.prototype = obj;
        return new F();
    }
    let person = {
        name: "Nicholas",
        friends: ["Shelby", "Court", "Van"]
    };
    let a_person = object(person);
    a_person.name = "Greg";
    a_person.friends.push("Rob");
    let b_person = object(person);
    b_person.name = "Linda";
    b_person.friends.push("Barbie");
    console.log(person); // {name: 'Nicholas', friends: Array(5)}
    console.log(person.friends); // ['Shelby', 'Court', 'Van', 'Rob', 'Barbie']
    console.log(a_person); // {name: 'Greg'}
    console.log(a_person.friends); // ['Shelby', 'Court', 'Van', 'Rob', 'Barbie']
    console.log(b_person); // {name: 'Linda'}
    console.log(b_person.friends); // ['Shelby', 'Court', 'Van', 'Rob', 'Barbie']
}
//#endregion
//#region 寄生式继承
{
    function object(obj) {
        function F() { }
        F.prototype = obj;
        return new F();
    }
    //其实就是在原型式继承上，对新对象进行了“强化”
    function createAnother(original) {
        let clone = object(original); // 通过调用函数创建一个新对象 
        clone.sayHi = function () {
            console.log("hi");
        };
        return clone; // 返回这个对象 }
    }
}
//#endregion
//#region 寄生式组合继承
// 寄生式组合继承：
{
    function object(o) {
        function F() { }
        F.prototype = o;
        return new F();
    }
    function inheritPropertype(Sub, SuperType) {
        let prototype = object(SuperType); // 创建对象：原型式继承
        prototype.constructor = Sub; // 增强对象：修改父类构造函数的实例，属于寄生式继承，指定constructor是为了解决重写子类原型导致的constructor丢失
        Sub.prototype = prototype; // 赋值对象：赋值修改prototype
    }
}
//#endregion
//#endregion
